﻿using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;

namespace Systemet.Technical
{
    /// <summary>
    /// Klassen används för att returnera konton, kostnader på konton, schablonkostnader,
    /// produktallokeringar, aktivitetsallokeringar, personalallokeringar, aktivitets och produktkostnader.
    /// </summary>
    class KostnadsbudConnection
    {
        private LinqToSQLDataContext database;
        private string pass = AccessController.Instance.Connection;
        private string connection;

        //Hämtar alla Konton //ANVÄNDS INTE NÅGONSTANS!!
        //public List<Konto> Retrivekonto()
        //{
        //    try
        //    {
        //        connection = AccessController.Instance.Connection;
        //        database = new LinqToSQLDataContext(connection);
        //        var konto = from Konto in database.Kontoregisters
        //                    join Kostnadskonto in database.Kostnadskontoregisters on Konto.kontonummer equals Kostnadskonto.kontonummer
        //                    select new { Konto.kontobenämning, Kostnadskonto.kontonummer, Kostnadskonto.schablonkostnader };
        //        Konto kontot = new Konto();
        //        List<Konto> Kontolista = konto.AsEnumerable()
        //                        .Select(s => new Konto
        //                        {
        //                            Kontonummer = s.kontonummer,
        //                            Kontobenämning = s.kontobenämning,
        //                            Schablon = s.schablonkostnader
        //                        }).ToList();
        //        return Kontolista.ToList();
        //    }
        //    catch (Exception e)
        //    {
        //        MessageBox.Show(e.ToString());
        //        return null;
        //    }
        //    finally
        //    {
        //        database.Connection.Close();
        //    }
        //}


        //Behöver se ut som den gör, annars måste vi använda oss av Kontoregister + Partial-klass
        //Hämtar konto mellan textboxar
        public List<Konto> GetKonto(string kontonummerfran, string kontonummertill)
        {
            try
            {
                database = new LinqToSQLDataContext(pass);

                var kontona = from Kontoregister in database.Kontoregisters
                              join Kostnadskonto in database.Kostnadskontoregisters on Kontoregister.kontonummer equals Kostnadskonto.kontonummer
                              where Kontoregister.kontonummer.CompareTo(kontonummerfran) >= 0 && Kontoregister.kontonummer != "5021"
                              && Kontoregister.kontonummer.CompareTo(kontonummertill) <= 0 && Kontoregister.kontonummer != "9999"
                              select new { Kontoregister.kontobenämning, Kostnadskonto.kontonummer, Kostnadskonto.schablonkostnader };
                //Konto kontot = new Konto();

                List<Konto> Kontolista = kontona.AsEnumerable()
                           .Select(s => new Konto
                           {
                               Kontonummer = s.kontonummer,
                               Kontobenämning = s.kontobenämning,
                               Schablon = s.schablonkostnader

                           }).ToList();

                database.Connection.Close();
                return Kontolista;
            }
            catch (Exception e)
            {
                database.Connection.Close();
                return null;
            }
        }

        public IEnumerable<Kostnadskontoregister> GetKostnadskontoregister(string kontonummerfran, string kontonummertill)
        {
            try
            {
                database = new LinqToSQLDataContext(pass);

                IEnumerable<Kostnadskontoregister> kostKonton = from Kostnadskontoregister in database.Kostnadskontoregisters
                                                                where Kostnadskontoregister.kontonummer.CompareTo(kontonummerfran) >= 0 && Kostnadskontoregister.kontonummer != "5021"
                                                                && Kostnadskontoregister.kontonummer.CompareTo(kontonummertill) <= 0 && Kostnadskontoregister.kontonummer != "9999"
                                                                select Kostnadskontoregister;
                database.Connection.Close();
                return kostKonton;
            }
            catch (Exception e)
            {
                database.Connection.Close();
                return null;
            }
        }

        //Hämtar alla konton
        public IEnumerable<Kontoregister> getKonton()
        {
            try
            {
                database = new LinqToSQLDataContext(pass);

                IEnumerable<Kontoregister> konton = from Kontoregister in database.Kontoregisters
                                                    where Kontoregister.kontonummer != "5021" && Kontoregister.kontonummer != "9999"
                                                    select Kontoregister;

                //foreach (Kontoregister kR in konton)
                //{
                //    Konto nyKonto = new Konto();
                //    nyKonto.Kontonummer = kR.kontonummer;
                //    nyKonto.Kontobenämning = kR.kontobenämning;
                //    kontolista.Add(nyKonto);
                //}
                database.Connection.Close();
                return konton;
            }
            catch (Exception e)
            {
                database.Connection.Close();
                return null;
            }
        }

        //ANVÄNDS INTE!!
        //public List<Konto> GetKonto(string kbenämning)
        //{
        //    try
        //    {
        //        database = new LinqToSQLDataContext(pass);

        //        var kontona = from Konto in database.Kontoregisters
        //                      join Kostnadskonto in database.Kostnadskontoregisters on Konto.kontonummer equals Kostnadskonto.kontonummer
        //                      where Konto.kontobenämning.Contains(kbenämning)
        //                      select new { Konto.kontobenämning, Kostnadskonto.kontonummer, Kostnadskonto.schablonkostnader };
        //        Konto kontot = new Konto();

        //        List<Konto> Kontolista = kontona.AsEnumerable()
        //                   .Select(s => new Konto
        //                   {
        //                       Kontonummer = s.kontonummer,
        //                       Kontobenämning = s.kontobenämning,
        //                       Schablon = s.schablonkostnader
        //                   }).ToList();

        //        database.Connection.Close();
        //        return Kontolista.ToList();
        //    }
        //    catch (Exception e)
        //    {
        //        database.Connection.Close();
        //        return null;
        //    }
        //}


        //Lägger till Schablonkostnader
        public void Schablon(string kontonummer, int schablon)
        {
            try
            {
                database = new LinqToSQLDataContext(pass);
                var schablonkonton = (from Kostnadskonton in database.Kostnadskontoregisters
                                      where Kostnadskonton.kontonummer == kontonummer
                                      select Kostnadskonton).Single();

                schablonkonton.schablonkostnader = schablon;
                schablonkonton.ändratDatum = DateTime.Now;
                schablonkonton.låst = false;

                database.SubmitChanges();
            }
            catch (Exception e)
            {
                database.Connection.Close();
            }
        }


        public List<Produkt> RetrieveProductionAllocations(string prodgrupp, string prodKategori, string prodOmrade)
        {
            try
            {
                database = new LinqToSQLDataContext(pass);

                var products = from Produkt in database.Produktregisters
                               where Produkt.Produktkategori.produktKategoriNamn.Contains(prodKategori) &&
                               Produkt.Produktgrupp.produktGruppNamn.Contains(prodgrupp) && Produkt.avdelningsnamn.Contains(prodOmrade)
                               select Produkt;

                List<Produkt> produkter = new List<Produkt>();
                foreach (Produktregister p in products)
                {
                    Produkt prod = new Produkt();
                    prod.ProduktNamn = p.produkt;
                    prod.ProduktKategori = p.Produktkategori.produktKategoriNamn;
                    prod.ProduktGrupp = p.Produktgrupp.produktGruppNamn;
                    prod.Produktionsomrade = p.avdelningsnamn;
                    produkter.Add(prod);

                }

                database.Connection.Close();
                return produkter;
            }
            catch (Exception e)
            {
                database.Connection.Close();
                return null;
            }
        }

        public List<Personal> RetrieveStaffAllocations(string ProdOmrade)
        {
            try
            {
                database = new LinqToSQLDataContext(pass);
                var allocations = from Personal in database.Personalregisters
                                  join Personalavdelning in database.Personalavdelnings on Personal.personnummer equals Personalavdelning.personnummer
                                  where Personalavdelning.avdelningsnamn.Contains(ProdOmrade)
                                  select new { Personal.personnummer, Personal.Fnamn, Personal.Enamn, Personal.Sysselsättningsgrad, Personal.Vakansavdrag, Personal.Månadslön };


                if (allocations != null)
                {
                    List<Personal> allokeringar = allocations.AsEnumerable()
                                    .Select(s => new Personal
                                    {
                                        Personnummer = s.personnummer,
                                        Förnamn = s.Fnamn,
                                        Efternamn = s.Enamn,
                                        Sysselsättningsgrad = s.Sysselsättningsgrad,
                                        Vakansavdrag = s.Vakansavdrag,
                                        Månadslön = s.Månadslön
                                    }).ToList();

                    return allokeringar;
                }
                return null;
            }
            catch (Exception e)
            {
                database.Connection.Close();
                return null;
            }
        }


        //Hämta alla produkt allokeringar
        public List<ResursAllokeringar> GetAllocations()
        {
            try
            {
                database = new LinqToSQLDataContext(pass);

                var query = from Produktallokering in database.Produktallokerings
                            where Produktallokering.Produktregister.avdelningsnamn.Contains("Drift") || Produktallokering.Produktregister.avdelningsnamn.Contains("Utv")
                            select new { Produktallokering.personnummer, Produktallokering.produktID, Produktallokering.Produktregister.produkt, Produktallokering.procentsats, Produktallokering.Produktregister.avdelningsnamn };

                List<ResursAllokeringar> allokeringar = query.AsEnumerable()
                    .Select(s => new ResursAllokeringar
                    {
                        PersNr = s.personnummer,
                        ProduktID = s.produktID,
                        ProcentSats = s.procentsats,
                        Produkt = s.produkt,
                        Avdelningsnamn = s.avdelningsnamn
                    }).ToList();


                return allokeringar;
            }
            catch (Exception e)
            {
                database.Connection.Close();
                return null;
            }
        }

        //Hämta alla Aktivitets allokeringar
        public List<AktivitetsAllokeringar> GetActivityAllocations(string prodomrade)
        {
            try
            {
                database = new LinqToSQLDataContext(pass);

                var q = from Aktivitetsallokering in database.Aktivitetsallokerings
                        where Aktivitetsallokering.Aktivietetsregister.avdelningsnamn.Contains("Adm") || Aktivitetsallokering.Aktivietetsregister.avdelningsnamn.Contains("mark")
                        select new
                        {
                            Aktivitetsallokering.personnummer,
                            Aktivitetsallokering.aktivitetsID,
                            Aktivitetsallokering.procentsats,
                            Aktivitetsallokering.Aktivietetsregister.avdelningsnamn,
                            Aktivitetsallokering.Aktivietetsregister.aktivitet,
                            Aktivitetsallokering.ändratDatum
                        };


                List<AktivitetsAllokeringar> allokeringar = q.AsEnumerable()
                    .Select(s => new AktivitetsAllokeringar
                    {
                        PersNr = s.personnummer,
                        AktivitetsID = s.aktivitetsID,
                        Procentsats = s.procentsats,
                        Avdelningsnamn = s.avdelningsnamn,
                        Aktivitet = s.aktivitet,
                        ÄndratDatum = (DateTime)s.ändratDatum
                    }).ToList();

                database.Connection.Close();
                return allokeringar;
            }
            catch (Exception e)
            {
                database.Connection.Close();
                return null;
            }
        }

        //Hämta procentandel per avdelning
        public List<Personalavdelning> RetrieveStaffPercentages()
        {
            try
            {
                database = new LinqToSQLDataContext(pass);

                var query = from Personalavdelning in database.Personalavdelnings
                            join Personal in database.Personalregisters on Personalavdelning.personnummer equals Personal.personnummer
                            select Personalavdelning;

                List<Personalavdelning> pA = query.AsEnumerable().Select(p => new Personalavdelning
                {
                    personnummer = p.personnummer,
                    avdelningsnamn = p.avdelningsnamn,
                    procentsats = p.procentsats,
                    Månadslön = p.Personalregister.Månadslön
                }).ToList();

                return pA;
            }
            catch (Exception e)
            {
                database.Connection.Close();
                return null;
            }
        }


        //Hämta aktuell allokerings procent för en person på produkter inom en avd
        public int CheckStaffAllocationsOnProducts(string persNr, string prodOmrade)
        {
            try
            {
                database = new LinqToSQLDataContext(pass);

                var q = from Produktallokering in database.Produktallokerings
                        join Personal in database.Personalregisters on Produktallokering.personnummer equals Personal.personnummer
                        where Produktallokering.personnummer == persNr && Produktallokering.Produktregister.avdelningsnamn.Contains(prodOmrade)
                        select new { Produktallokering.personnummer, Produktallokering.procentsats, Produktallokering.Produktregister.avdelningsnamn };

                List<ResursAllokeringar> resA = q.AsEnumerable().Select(r => new ResursAllokeringar
                {
                    PersNr = r.personnummer,
                    ProcentSats = r.procentsats

                }).ToList();

                int TotalAllokerat = 0;
                foreach (ResursAllokeringar rA in resA)
                {
                    TotalAllokerat += (int)rA.ProcentSats;

                }
                database.Connection.Close();
                return TotalAllokerat;
            }
            catch (Exception e)
            {
                database.Connection.Close();
                return -1;
            }
        }
        //Hämta aktuell allokerings procent för en person på aktiviter inom en avd
        public int CheckStaffAllocationsOnActivities(string persNr, string prodOmrade)
        {
            try
            {
                database = new LinqToSQLDataContext(pass);

                var q = from Aktivitetsallokering in database.Aktivitetsallokerings
                        join Personal in database.Personalregisters on Aktivitetsallokering.personnummer equals Personal.personnummer
                        join Aktivietetsregister in database.Aktivietetsregisters on Aktivitetsallokering.aktivitetsID equals Aktivietetsregister.aktivitetsID
                        where Aktivitetsallokering.personnummer == persNr && Aktivietetsregister.avdelningsnamn.Contains(prodOmrade)
                        select new { Aktivitetsallokering.personnummer, Aktivitetsallokering.procentsats, Aktivietetsregister.avdelningsnamn };

                List<AktivitetsAllokeringar> AktivAllo = q.AsEnumerable().Select(a => new AktivitetsAllokeringar
                {
                    PersNr = a.personnummer,
                    Procentsats = a.procentsats

                }).ToList();

                int TotalAllokerat = 0;
                foreach (AktivitetsAllokeringar aA in AktivAllo)
                {
                    TotalAllokerat += (int)aA.Procentsats;
                }
                database.Connection.Close();
                return TotalAllokerat;
            }
            catch (Exception e)
            {
                database.Connection.Close();
                return -1;
            }
        }

        //Lägg in ny ProduktAllokering på personal
        public bool InsertStaffAllocationOnProduct(ResursAllokeringar ra)
        {
            try
            {
                database = new LinqToSQLDataContext(pass);
                Produktallokering NyAllokering = new Produktallokering
                {
                    produktID = ra.ProduktID,
                    personnummer = ra.PersNr,
                    procentsats = ra.ProcentSats,
                    ändratDatum = DateTime.Now,
                    låst = false
                };

                database.Produktallokerings.InsertOnSubmit(NyAllokering);
                database.SubmitChanges();
                database.Connection.Close();
                return true;
            }
            catch (Exception e)
            {
                database.Connection.Close();
                return false;
            }
        }

        //Lägg in ny Aktivitetsallokering på personal
        public bool InsertStaffAllocationOnActicity(AktivitetsAllokeringar aA)
        {
            try
            {
                database = new LinqToSQLDataContext(pass);
                Aktivitetsallokering NyAllokering = new Aktivitetsallokering
                {
                    aktivitetsID = aA.AktivitetsID,
                    personnummer = aA.PersNr,
                    procentsats = aA.Procentsats,
                    ändratDatum = DateTime.Now,
                    låst = false
                };

                database.Aktivitetsallokerings.InsertOnSubmit(NyAllokering);
                database.SubmitChanges();
                database.Connection.Close();
                return true;
            }
            catch (Exception e)
            {
                database.Connection.Close();
                return false;
            }
        }
        //Uppdatera Allokering på produkt 
        public bool UpdateStaffAllocationOnProducts(ResursAllokeringar ra)
        {
            try
            {
                database = new LinqToSQLDataContext(pass);
                Produktallokering UppdateraAllokering = database.Produktallokerings.Single(u => u.produktID == ra.ProduktID && u.personnummer == ra.PersNr);
                {
                    UppdateraAllokering.procentsats = ra.ProcentSats;
                    UppdateraAllokering.ändratDatum = DateTime.Now;
                };

                database.SubmitChanges();
                database.Connection.Close();
                return true;
            }
            catch (Exception e)
            {
                database.Connection.Close();
                return false;
            }
        }

        //Uppdatera Allokering på Aktivitet 
        public bool UpdateStaffAllocationOnActivity(AktivitetsAllokeringar aA)
        {
            try
            {
                database = new LinqToSQLDataContext(pass);
                Aktivitetsallokering UppdateraAllokering = database.Aktivitetsallokerings.Single(a => a.aktivitetsID == aA.AktivitetsID && a.personnummer == aA.PersNr);
                {
                    UppdateraAllokering.procentsats = aA.Procentsats;
                    UppdateraAllokering.ändratDatum = DateTime.Now;
                };

                database.SubmitChanges();
                database.Connection.Close();
                return true;
            }
            catch (Exception e)
            {
                database.Connection.Close();
                return false;
            }
        }
        //Ta bort allokering på produkt
        public bool RemoveStaffAllocationOnProducts(ResursAllokeringar rA)
        {
            try
            {
                database = new LinqToSQLDataContext(pass);
                Produktallokering RemoveAllocation = database.Produktallokerings.Single(r => r.produktID == rA.ProduktID && r.personnummer == rA.PersNr);

                database.Produktallokerings.DeleteOnSubmit(RemoveAllocation);
                database.SubmitChanges();
                database.Connection.Close();
                return true;
            }
            catch (Exception e)
            {
                database.Connection.Close();
                return false;
            }
        }

        //Ta bort allokering på Aktivitet
        public bool RemoveStaffAllocationOnActivity(AktivitetsAllokeringar aA)
        {
            try
            {
                database = new LinqToSQLDataContext(pass);
                Aktivitetsallokering RemoveAllocation = database.Aktivitetsallokerings.Single(r => r.aktivitetsID == aA.AktivitetsID && r.personnummer == aA.PersNr);

                database.Aktivitetsallokerings.DeleteOnSubmit(RemoveAllocation);
                database.SubmitChanges();
                database.Connection.Close();
                return true;
            }
            catch (Exception e)
            {
                database.Connection.Close();
                return false;
            }
        }

        //Direkotkostnadsbudgetering Hämta alla konton efter sökkriterier
        public List<Kontoregister> GetFilteredAccounts(string Kfran, string ktill)
        {
            try
            {
                database = new LinqToSQLDataContext(pass);

                IEnumerable<Kontoregister> kontona = from Kontoregister in database.Kontoregisters
                                                     where Kontoregister.kontonummer.CompareTo(Kfran) >= 0
                                                     && Kontoregister.kontonummer.CompareTo(ktill) <= 0
                                                     && Kontoregister.kontonummer != "5021"
                                                     select Kontoregister;

                //Kontoregister kontot = new Kontoregister();

                return kontona.ToList();
            }
            catch (Exception e)
            {
                database.Connection.Close();
                return null;
            }
        }

        public List<Konto> GetFilteredAccountsAndSchablon(string Kfran, string ktill)
        {
            try
            {
                database = new LinqToSQLDataContext(pass);

                var kontona = from Konto in database.Kontoregisters
                              where Konto.kontonummer.CompareTo(Kfran) >= 0
                              && Konto.kontonummer.CompareTo(ktill) <= 0
                              && Konto.kontonummer != "5021" && Konto.kontonummer != "9999"
                              select new { Konto.kontobenämning, Konto.kontonummer, Konto.Kostnadskontoregister.schablonkostnader };
                Konto kontot = new Konto();

                List<Konto> Kontolista = kontona.AsEnumerable()
                           .Select(s => new Konto
                           {
                               Kontonummer = s.kontonummer,
                               Kontobenämning = s.kontobenämning,
                               Schablon = s.schablonkostnader

                           }).ToList();

                database.Connection.Close();
                return Kontolista.ToList();
            }
            catch (Exception e)
            {
                database.Connection.Close();
                return null;
            }
        }

        public List<ProduktKostnad> RetrieveProductCosts(string Kfran, string ktill, string avd)
        {
            try
            {
                database = new LinqToSQLDataContext(pass);

                var kontona = from Produktkostnad in database.Produktkostnads
                              join Produkt in database.Produktregisters on Produktkostnad.produktID equals Produkt.produktID
                              where Produktkostnad.kontonummer.CompareTo(Kfran) >= 0
                              && Produktkostnad.kontonummer.CompareTo(ktill) <= 0
                              && Produktkostnad.kontonummer != "5021" && Produkt.avdelningsnamn.Contains(avd)
                              && Produktkostnad.kontonummer != "5021" && Produktkostnad.kontonummer != "9999" && Produktkostnad.Produktregister.avdelningsnamn.Contains(avd)
                              select new { Produktkostnad.produktID, Produktkostnad.kontonummer, Produktkostnad.belopp };



                List<ProduktKostnad> Kontolista = kontona.AsEnumerable()
                           .Select(s => new ProduktKostnad
                           {
                               Kontonummer = s.kontonummer,
                               ProduktID = s.produktID,
                               Belopp = s.belopp

                           }).ToList();

                database.Connection.Close();
                return Kontolista;
            }
            catch (Exception e)
            {
                database.Connection.Close();
                return null;
            }
        }


        public List<AktivitetsKostnad> RetrieveActivityCosts(string Kfran, string ktill, string avd)
        {
            try
            {
                database = new LinqToSQLDataContext(pass);

                var kontona = from Aktivitetskostnad in database.Aktivitetskostnads
                              join Aktivitet in database.Aktivietetsregisters on Aktivitetskostnad.aktivitetsID equals Aktivitet.aktivitetsID
                              where Aktivitetskostnad.kontonummer.CompareTo(Kfran) >= 0
                              && Aktivitetskostnad.kontonummer.CompareTo(ktill) <= 0
                              && Aktivitetskostnad.kontonummer != "5021" && Aktivitet.avdelningsnamn.Contains(avd)
                              select new { Aktivitetskostnad.kontonummer, Aktivitetskostnad.aktivitetsID, Aktivitetskostnad.belopp };


                List<AktivitetsKostnad> Kontolista = kontona.AsEnumerable()
                           .Select(s => new AktivitetsKostnad
                           {
                               Kontonummer = s.kontonummer,
                               AktivitetsID = s.aktivitetsID,
                               Belopp = s.belopp

                           }).ToList();

                database.Connection.Close();
                return Kontolista;
            }
            catch (Exception e)
            {
                database.Connection.Close();
                return null;
            }
        }

        //Insert av direkt Produktkostnads allokering
        public bool InsertDirectProductCost(ProduktKostnad pK)
        {
            try
            {
                database = new LinqToSQLDataContext(pass);
                Produktkostnad NyAllokering = new Produktkostnad
                {
                    produktID = pK.ProduktID,
                    kontonummer = pK.Kontonummer,
                    belopp = pK.Belopp,
                    ändratDatum = DateTime.Now,
                    låst = false
                };

                database.Produktkostnads.InsertOnSubmit(NyAllokering);
                database.SubmitChanges();
                database.Connection.Close();
                return true;
            }
            catch (Exception e)
            {
                database.Connection.Close();
                return false;
            }
        }

        //Insert av direkt Aktivitetskostnad allokering
        public bool InsertDirectActivityCost(AktivitetsKostnad aK)
        {
            try
            {
                database = new LinqToSQLDataContext(pass);
                Aktivitetskostnad NyAllokering = new Aktivitetskostnad
                {
                    aktivitetsID = aK.AktivitetsID,
                    kontonummer = aK.Kontonummer,
                    belopp = aK.Belopp,
                    ändratDatum = DateTime.Now,
                    låst = false
                };


                database.Aktivitetskostnads.InsertOnSubmit(NyAllokering);
                database.SubmitChanges();
                database.Connection.Close();
                return true;
            }
            catch (Exception e)
            {
                database.Connection.Close();
                return false;
            }
        }

        //Uppdatera Allokering på direktkostnad av Produkt
        public bool UpdateProductCost(ProduktKostnad pK)
        {
            try
            {
                database = new LinqToSQLDataContext(pass);
                Produktkostnad UppdateraAllokering = database.Produktkostnads.Single(a => a.produktID == pK.ProduktID && a.kontonummer == pK.Kontonummer);
                {
                    UppdateraAllokering.belopp = pK.Belopp;
                    UppdateraAllokering.ändratDatum = DateTime.Now;
                };

                database.SubmitChanges();
                database.Connection.Close();
                return true;
            }
            catch (Exception e)
            {
                database.Connection.Close();
                return false;
            }
        }

        //Uppdatera Allokering på direktkostnad av Aktivitet
        public bool UpdateActivityCost(AktivitetsKostnad aK)
        {
            try
            {
                database = new LinqToSQLDataContext(pass);
                Aktivitetskostnad UppdateraAllokering = database.Aktivitetskostnads.Single(a => a.aktivitetsID == aK.AktivitetsID && a.kontonummer == aK.Kontonummer);
                {
                    UppdateraAllokering.belopp = aK.Belopp;
                    UppdateraAllokering.ändratDatum = DateTime.Now;
                };

                database.SubmitChanges();
                database.Connection.Close();
                return true;
            }
            catch (Exception e)
            {
                database.Connection.Close();
                return false;
            }
        }

        //Ta bort allokering av DirektKostnad på produkt
        public bool RemoveDirectCostOnProduct(string konto, string ID)
        {
            try
            {
                database = new LinqToSQLDataContext(pass);
                Produktkostnad RemoveAllocation = database.Produktkostnads.Single(r => r.produktID == ID && r.kontonummer == konto);

                database.Produktkostnads.DeleteOnSubmit(RemoveAllocation);
                database.SubmitChanges();
                database.Connection.Close();
                return true;
            }
            catch (Exception e)
            {
                database.Connection.Close();
                return false;
            }
        }

        //Ta bort allokering av DirektKostnad på Aktivitet
        public bool RemoveDirectCostOnActivity(string konto, string ID)
        {
            try
            {
                database = new LinqToSQLDataContext(pass);
                Aktivitetskostnad RemoveAllocation = database.Aktivitetskostnads.Single(r => r.aktivitetsID == ID && r.kontonummer == konto);

                database.Aktivitetskostnads.DeleteOnSubmit(RemoveAllocation);
                database.SubmitChanges();
                database.Connection.Close();
                return true;
            }
            catch (Exception e)
            {
                database.Connection.Close();
                return false;
            }
        }
    }
}
